using GalaSoft.MvvmLight;
using System.Windows.Input;
using GalaSoft.MvvmLight.Command;
using System.Linq;
using ASoft.Msg;
using System;

namespace ASoft.WPF.ViewModel
{
	public partial class RoomSetBaseViewModel : ViewModelBase
    {
		#region "P1拉幕风速上限"

        private Byte _P1拉幕风速上限 = default(Byte);

        public Byte P1拉幕风速上限
        {
            get
            {
                return _P1拉幕风速上限;
            }
            set
            {
                if (_P1拉幕风速上限 == value)
                {
                    return;
                }

                _P1拉幕风速上限 = value;
                RaisePropertyChanged("P1拉幕风速上限");
            }
        }

        #endregion
		#region "P1拉幕手动自动标志"

        private Byte _P1拉幕手动自动标志 = default(Byte);

        public Byte P1拉幕手动自动标志
        {
            get
            {
                return _P1拉幕手动自动标志;
            }
            set
            {
                if (_P1拉幕手动自动标志 == value)
                {
                    return;
                }

                _P1拉幕手动自动标志 = value;
                RaisePropertyChanged("P1拉幕手动自动标志");
            }
        }

        #endregion
		#region "P1拉幕手动自动标志ACC"

        private Byte _P1拉幕手动自动标志ACC = default(Byte);

        public Byte P1拉幕手动自动标志ACC
        {
            get
            {
                return _P1拉幕手动自动标志ACC;
            }
            set
            {
                if (_P1拉幕手动自动标志ACC == value)
                {
                    return;
                }

                _P1拉幕手动自动标志ACC = value;
                RaisePropertyChanged("P1拉幕手动自动标志ACC");
            }
        }

        #endregion
		#region "P1拉幕手动运行方向"

        private Byte _P1拉幕手动运行方向 = default(Byte);

        public Byte P1拉幕手动运行方向
        {
            get
            {
                return _P1拉幕手动运行方向;
            }
            set
            {
                if (_P1拉幕手动运行方向 == value)
                {
                    return;
                }

                _P1拉幕手动运行方向 = value;
                RaisePropertyChanged("P1拉幕手动运行方向");
            }
        }

        #endregion
		#region "P1拉幕手动运行方向ACC"

        private Byte _P1拉幕手动运行方向ACC = default(Byte);

        public Byte P1拉幕手动运行方向ACC
        {
            get
            {
                return _P1拉幕手动运行方向ACC;
            }
            set
            {
                if (_P1拉幕手动运行方向ACC == value)
                {
                    return;
                }

                _P1拉幕手动运行方向ACC = value;
                RaisePropertyChanged("P1拉幕手动运行方向ACC");
            }
        }

        #endregion
		#region "P1拉幕手动运行幅度"

        private Byte _P1拉幕手动运行幅度 = default(Byte);

        public Byte P1拉幕手动运行幅度
        {
            get
            {
                return _P1拉幕手动运行幅度;
            }
            set
            {
                if (_P1拉幕手动运行幅度 == value)
                {
                    return;
                }

                _P1拉幕手动运行幅度 = value;
                RaisePropertyChanged("P1拉幕手动运行幅度");
            }
        }

        #endregion
		#region "P1拉幕光照上限"

        private Int16 _P1拉幕光照上限 = default(Int16);

        public Int16 P1拉幕光照上限
        {
            get
            {
                return _P1拉幕光照上限;
            }
            set
            {
                if (_P1拉幕光照上限 == value)
                {
                    return;
                }

                _P1拉幕光照上限 = value;
                RaisePropertyChanged("P1拉幕光照上限");
            }
        }

        #endregion
		#region "P1拉幕光照下限"

        private Int16 _P1拉幕光照下限 = default(Int16);

        public Int16 P1拉幕光照下限
        {
            get
            {
                return _P1拉幕光照下限;
            }
            set
            {
                if (_P1拉幕光照下限 == value)
                {
                    return;
                }

                _P1拉幕光照下限 = value;
                RaisePropertyChanged("P1拉幕光照下限");
            }
        }

        #endregion
		#region "P1拉幕光照有效性"

        private Byte _P1拉幕光照有效性 = default(Byte);

        public Byte P1拉幕光照有效性
        {
            get
            {
                return _P1拉幕光照有效性;
            }
            set
            {
                if (_P1拉幕光照有效性 == value)
                {
                    return;
                }

                _P1拉幕光照有效性 = value;
                RaisePropertyChanged("P1拉幕光照有效性");
            }
        }

        #endregion
		#region "P1拉幕光照有效性ACC"

        private Byte _P1拉幕光照有效性ACC = default(Byte);

        public Byte P1拉幕光照有效性ACC
        {
            get
            {
                return _P1拉幕光照有效性ACC;
            }
            set
            {
                if (_P1拉幕光照有效性ACC == value)
                {
                    return;
                }

                _P1拉幕光照有效性ACC = value;
                RaisePropertyChanged("P1拉幕光照有效性ACC");
            }
        }

        #endregion
		#region "P1拉幕温室温度上限"

        private Byte _P1拉幕温室温度上限 = default(Byte);

        public Byte P1拉幕温室温度上限
        {
            get
            {
                return _P1拉幕温室温度上限;
            }
            set
            {
                if (_P1拉幕温室温度上限 == value)
                {
                    return;
                }

                _P1拉幕温室温度上限 = value;
                RaisePropertyChanged("P1拉幕温室温度上限");
            }
        }

        #endregion
		#region "P1拉幕温室温度下限"

        private Byte _P1拉幕温室温度下限 = default(Byte);

        public Byte P1拉幕温室温度下限
        {
            get
            {
                return _P1拉幕温室温度下限;
            }
            set
            {
                if (_P1拉幕温室温度下限 == value)
                {
                    return;
                }

                _P1拉幕温室温度下限 = value;
                RaisePropertyChanged("P1拉幕温室温度下限");
            }
        }

        #endregion
		#region "P1拉幕温室温度有效性"

        private Byte _P1拉幕温室温度有效性 = default(Byte);

        public Byte P1拉幕温室温度有效性
        {
            get
            {
                return _P1拉幕温室温度有效性;
            }
            set
            {
                if (_P1拉幕温室温度有效性 == value)
                {
                    return;
                }

                _P1拉幕温室温度有效性 = value;
                RaisePropertyChanged("P1拉幕温室温度有效性");
            }
        }

        #endregion
		#region "P1拉幕温室温度有效性ACC"

        private Byte _P1拉幕温室温度有效性ACC = default(Byte);

        public Byte P1拉幕温室温度有效性ACC
        {
            get
            {
                return _P1拉幕温室温度有效性ACC;
            }
            set
            {
                if (_P1拉幕温室温度有效性ACC == value)
                {
                    return;
                }

                _P1拉幕温室温度有效性ACC = value;
                RaisePropertyChanged("P1拉幕温室温度有效性ACC");
            }
        }

        #endregion
		#region "P1拉幕确认时间"

        private Byte _P1拉幕确认时间 = default(Byte);

        public Byte P1拉幕确认时间
        {
            get
            {
                return _P1拉幕确认时间;
            }
            set
            {
                if (_P1拉幕确认时间 == value)
                {
                    return;
                }

                _P1拉幕确认时间 = value;
                RaisePropertyChanged("P1拉幕确认时间");
            }
        }

        #endregion
		#region "P1拉幕全程运行时间字符串"

        private String _P1拉幕全程运行时间字符串 = default(String);

        public String P1拉幕全程运行时间字符串
        {
            get
            {
                return _P1拉幕全程运行时间字符串;
            }
            set
            {
                if (_P1拉幕全程运行时间字符串 == value)
                {
                    return;
                }

                _P1拉幕全程运行时间字符串 = value;
                RaisePropertyChanged("P1拉幕全程运行时间字符串");
            }
        }

        #endregion
		#region "P2拉幕手动自动标志"

        private Byte _P2拉幕手动自动标志 = default(Byte);

        public Byte P2拉幕手动自动标志
        {
            get
            {
                return _P2拉幕手动自动标志;
            }
            set
            {
                if (_P2拉幕手动自动标志 == value)
                {
                    return;
                }

                _P2拉幕手动自动标志 = value;
                RaisePropertyChanged("P2拉幕手动自动标志");
            }
        }

        #endregion
		#region "P2拉幕手动自动标志ACC"

        private Byte _P2拉幕手动自动标志ACC = default(Byte);

        public Byte P2拉幕手动自动标志ACC
        {
            get
            {
                return _P2拉幕手动自动标志ACC;
            }
            set
            {
                if (_P2拉幕手动自动标志ACC == value)
                {
                    return;
                }

                _P2拉幕手动自动标志ACC = value;
                RaisePropertyChanged("P2拉幕手动自动标志ACC");
            }
        }

        #endregion
		#region "P2拉幕手动运行方向"

        private Byte _P2拉幕手动运行方向 = default(Byte);

        public Byte P2拉幕手动运行方向
        {
            get
            {
                return _P2拉幕手动运行方向;
            }
            set
            {
                if (_P2拉幕手动运行方向 == value)
                {
                    return;
                }

                _P2拉幕手动运行方向 = value;
                RaisePropertyChanged("P2拉幕手动运行方向");
            }
        }

        #endregion
		#region "P2拉幕手动运行方向ACC"

        private Byte _P2拉幕手动运行方向ACC = default(Byte);

        public Byte P2拉幕手动运行方向ACC
        {
            get
            {
                return _P2拉幕手动运行方向ACC;
            }
            set
            {
                if (_P2拉幕手动运行方向ACC == value)
                {
                    return;
                }

                _P2拉幕手动运行方向ACC = value;
                RaisePropertyChanged("P2拉幕手动运行方向ACC");
            }
        }

        #endregion
		#region "P2拉幕手动运行幅度"

        private Byte _P2拉幕手动运行幅度 = default(Byte);

        public Byte P2拉幕手动运行幅度
        {
            get
            {
                return _P2拉幕手动运行幅度;
            }
            set
            {
                if (_P2拉幕手动运行幅度 == value)
                {
                    return;
                }

                _P2拉幕手动运行幅度 = value;
                RaisePropertyChanged("P2拉幕手动运行幅度");
            }
        }

        #endregion
		#region "P2拉幕光照上限"

        private Int16 _P2拉幕光照上限 = default(Int16);

        public Int16 P2拉幕光照上限
        {
            get
            {
                return _P2拉幕光照上限;
            }
            set
            {
                if (_P2拉幕光照上限 == value)
                {
                    return;
                }

                _P2拉幕光照上限 = value;
                RaisePropertyChanged("P2拉幕光照上限");
            }
        }

        #endregion
		#region "P2拉幕光照下限"

        private Int16 _P2拉幕光照下限 = default(Int16);

        public Int16 P2拉幕光照下限
        {
            get
            {
                return _P2拉幕光照下限;
            }
            set
            {
                if (_P2拉幕光照下限 == value)
                {
                    return;
                }

                _P2拉幕光照下限 = value;
                RaisePropertyChanged("P2拉幕光照下限");
            }
        }

        #endregion
		#region "P2拉幕光照有效性"

        private Byte _P2拉幕光照有效性 = default(Byte);

        public Byte P2拉幕光照有效性
        {
            get
            {
                return _P2拉幕光照有效性;
            }
            set
            {
                if (_P2拉幕光照有效性 == value)
                {
                    return;
                }

                _P2拉幕光照有效性 = value;
                RaisePropertyChanged("P2拉幕光照有效性");
            }
        }

        #endregion
		#region "P2拉幕光照有效性ACC"

        private Byte _P2拉幕光照有效性ACC = default(Byte);

        public Byte P2拉幕光照有效性ACC
        {
            get
            {
                return _P2拉幕光照有效性ACC;
            }
            set
            {
                if (_P2拉幕光照有效性ACC == value)
                {
                    return;
                }

                _P2拉幕光照有效性ACC = value;
                RaisePropertyChanged("P2拉幕光照有效性ACC");
            }
        }

        #endregion
		#region "P2拉幕温室温度上限"

        private Byte _P2拉幕温室温度上限 = default(Byte);

        public Byte P2拉幕温室温度上限
        {
            get
            {
                return _P2拉幕温室温度上限;
            }
            set
            {
                if (_P2拉幕温室温度上限 == value)
                {
                    return;
                }

                _P2拉幕温室温度上限 = value;
                RaisePropertyChanged("P2拉幕温室温度上限");
            }
        }

        #endregion
		#region "P2拉幕温室温度下限"

        private Byte _P2拉幕温室温度下限 = default(Byte);

        public Byte P2拉幕温室温度下限
        {
            get
            {
                return _P2拉幕温室温度下限;
            }
            set
            {
                if (_P2拉幕温室温度下限 == value)
                {
                    return;
                }

                _P2拉幕温室温度下限 = value;
                RaisePropertyChanged("P2拉幕温室温度下限");
            }
        }

        #endregion
		#region "P2拉幕温室温度有效性"

        private Byte _P2拉幕温室温度有效性 = default(Byte);

        public Byte P2拉幕温室温度有效性
        {
            get
            {
                return _P2拉幕温室温度有效性;
            }
            set
            {
                if (_P2拉幕温室温度有效性 == value)
                {
                    return;
                }

                _P2拉幕温室温度有效性 = value;
                RaisePropertyChanged("P2拉幕温室温度有效性");
            }
        }

        #endregion
		#region "P2拉幕温室温度有效性ACC"

        private Byte _P2拉幕温室温度有效性ACC = default(Byte);

        public Byte P2拉幕温室温度有效性ACC
        {
            get
            {
                return _P2拉幕温室温度有效性ACC;
            }
            set
            {
                if (_P2拉幕温室温度有效性ACC == value)
                {
                    return;
                }

                _P2拉幕温室温度有效性ACC = value;
                RaisePropertyChanged("P2拉幕温室温度有效性ACC");
            }
        }

        #endregion
		#region "P2拉幕确认时间"

        private Byte _P2拉幕确认时间 = default(Byte);

        public Byte P2拉幕确认时间
        {
            get
            {
                return _P2拉幕确认时间;
            }
            set
            {
                if (_P2拉幕确认时间 == value)
                {
                    return;
                }

                _P2拉幕确认时间 = value;
                RaisePropertyChanged("P2拉幕确认时间");
            }
        }

        #endregion
		#region "P2拉幕全程运行时间字符串"

        private String _P2拉幕全程运行时间字符串 = default(String);

        public String P2拉幕全程运行时间字符串
        {
            get
            {
                return _P2拉幕全程运行时间字符串;
            }
            set
            {
                if (_P2拉幕全程运行时间字符串 == value)
                {
                    return;
                }

                _P2拉幕全程运行时间字符串 = value;
                RaisePropertyChanged("P2拉幕全程运行时间字符串");
            }
        }

        #endregion
		#region "P1通风窗手动自动标志"

        private Byte _P1通风窗手动自动标志 = default(Byte);

        public Byte P1通风窗手动自动标志
        {
            get
            {
                return _P1通风窗手动自动标志;
            }
            set
            {
                if (_P1通风窗手动自动标志 == value)
                {
                    return;
                }

                _P1通风窗手动自动标志 = value;
                RaisePropertyChanged("P1通风窗手动自动标志");
            }
        }

        #endregion
		#region "P1通风窗手动自动标志ACC"

        private Byte _P1通风窗手动自动标志ACC = default(Byte);

        public Byte P1通风窗手动自动标志ACC
        {
            get
            {
                return _P1通风窗手动自动标志ACC;
            }
            set
            {
                if (_P1通风窗手动自动标志ACC == value)
                {
                    return;
                }

                _P1通风窗手动自动标志ACC = value;
                RaisePropertyChanged("P1通风窗手动自动标志ACC");
            }
        }

        #endregion
		#region "P1通风窗手动运行方向"

        private Byte _P1通风窗手动运行方向 = default(Byte);

        public Byte P1通风窗手动运行方向
        {
            get
            {
                return _P1通风窗手动运行方向;
            }
            set
            {
                if (_P1通风窗手动运行方向 == value)
                {
                    return;
                }

                _P1通风窗手动运行方向 = value;
                RaisePropertyChanged("P1通风窗手动运行方向");
            }
        }

        #endregion
		#region "P1通风窗手动运行方向ACC"

        private Byte _P1通风窗手动运行方向ACC = default(Byte);

        public Byte P1通风窗手动运行方向ACC
        {
            get
            {
                return _P1通风窗手动运行方向ACC;
            }
            set
            {
                if (_P1通风窗手动运行方向ACC == value)
                {
                    return;
                }

                _P1通风窗手动运行方向ACC = value;
                RaisePropertyChanged("P1通风窗手动运行方向ACC");
            }
        }

        #endregion
		#region "P1通风窗手动运行幅度"

        private Byte _P1通风窗手动运行幅度 = default(Byte);

        public Byte P1通风窗手动运行幅度
        {
            get
            {
                return _P1通风窗手动运行幅度;
            }
            set
            {
                if (_P1通风窗手动运行幅度 == value)
                {
                    return;
                }

                _P1通风窗手动运行幅度 = value;
                RaisePropertyChanged("P1通风窗手动运行幅度");
            }
        }

        #endregion
		#region "P1通风窗温室温度有效性"

        private Byte _P1通风窗温室温度有效性 = default(Byte);

        public Byte P1通风窗温室温度有效性
        {
            get
            {
                return _P1通风窗温室温度有效性;
            }
            set
            {
                if (_P1通风窗温室温度有效性 == value)
                {
                    return;
                }

                _P1通风窗温室温度有效性 = value;
                RaisePropertyChanged("P1通风窗温室温度有效性");
            }
        }

        #endregion
		#region "P1通风窗温室温度有效性ACC"

        private Byte _P1通风窗温室温度有效性ACC = default(Byte);

        public Byte P1通风窗温室温度有效性ACC
        {
            get
            {
                return _P1通风窗温室温度有效性ACC;
            }
            set
            {
                if (_P1通风窗温室温度有效性ACC == value)
                {
                    return;
                }

                _P1通风窗温室温度有效性ACC = value;
                RaisePropertyChanged("P1通风窗温室温度有效性ACC");
            }
        }

        #endregion
		#region "P1通风窗温室温度上限"

        private Byte _P1通风窗温室温度上限 = default(Byte);

        public Byte P1通风窗温室温度上限
        {
            get
            {
                return _P1通风窗温室温度上限;
            }
            set
            {
                if (_P1通风窗温室温度上限 == value)
                {
                    return;
                }

                _P1通风窗温室温度上限 = value;
                RaisePropertyChanged("P1通风窗温室温度上限");
            }
        }

        #endregion
		#region "P1通风窗温室温度下限"

        private Byte _P1通风窗温室温度下限 = default(Byte);

        public Byte P1通风窗温室温度下限
        {
            get
            {
                return _P1通风窗温室温度下限;
            }
            set
            {
                if (_P1通风窗温室温度下限 == value)
                {
                    return;
                }

                _P1通风窗温室温度下限 = value;
                RaisePropertyChanged("P1通风窗温室温度下限");
            }
        }

        #endregion
		#region "P1通风窗室外温度下限"

        private Byte _P1通风窗室外温度下限 = default(Byte);

        public Byte P1通风窗室外温度下限
        {
            get
            {
                return _P1通风窗室外温度下限;
            }
            set
            {
                if (_P1通风窗室外温度下限 == value)
                {
                    return;
                }

                _P1通风窗室外温度下限 = value;
                RaisePropertyChanged("P1通风窗室外温度下限");
            }
        }

        #endregion
		#region "P1通风窗确认时间"

        private Byte _P1通风窗确认时间 = default(Byte);

        public Byte P1通风窗确认时间
        {
            get
            {
                return _P1通风窗确认时间;
            }
            set
            {
                if (_P1通风窗确认时间 == value)
                {
                    return;
                }

                _P1通风窗确认时间 = value;
                RaisePropertyChanged("P1通风窗确认时间");
            }
        }

        #endregion
		#region "P1通风窗全程运行时间字符串"

        private String _P1通风窗全程运行时间字符串 = default(String);

        public String P1通风窗全程运行时间字符串
        {
            get
            {
                return _P1通风窗全程运行时间字符串;
            }
            set
            {
                if (_P1通风窗全程运行时间字符串 == value)
                {
                    return;
                }

                _P1通风窗全程运行时间字符串 = value;
                RaisePropertyChanged("P1通风窗全程运行时间字符串");
            }
        }

        #endregion
		#region "P2通风窗手动自动标志"

        private Byte _P2通风窗手动自动标志 = default(Byte);

        public Byte P2通风窗手动自动标志
        {
            get
            {
                return _P2通风窗手动自动标志;
            }
            set
            {
                if (_P2通风窗手动自动标志 == value)
                {
                    return;
                }

                _P2通风窗手动自动标志 = value;
                RaisePropertyChanged("P2通风窗手动自动标志");
            }
        }

        #endregion
		#region "P2通风窗手动自动标志ACC"

        private Byte _P2通风窗手动自动标志ACC = default(Byte);

        public Byte P2通风窗手动自动标志ACC
        {
            get
            {
                return _P2通风窗手动自动标志ACC;
            }
            set
            {
                if (_P2通风窗手动自动标志ACC == value)
                {
                    return;
                }

                _P2通风窗手动自动标志ACC = value;
                RaisePropertyChanged("P2通风窗手动自动标志ACC");
            }
        }

        #endregion
		#region "P2通风窗手动运行方向"

        private Byte _P2通风窗手动运行方向 = default(Byte);

        public Byte P2通风窗手动运行方向
        {
            get
            {
                return _P2通风窗手动运行方向;
            }
            set
            {
                if (_P2通风窗手动运行方向 == value)
                {
                    return;
                }

                _P2通风窗手动运行方向 = value;
                RaisePropertyChanged("P2通风窗手动运行方向");
            }
        }

        #endregion
		#region "P2通风窗手动运行方向ACC"

        private Byte _P2通风窗手动运行方向ACC = default(Byte);

        public Byte P2通风窗手动运行方向ACC
        {
            get
            {
                return _P2通风窗手动运行方向ACC;
            }
            set
            {
                if (_P2通风窗手动运行方向ACC == value)
                {
                    return;
                }

                _P2通风窗手动运行方向ACC = value;
                RaisePropertyChanged("P2通风窗手动运行方向ACC");
            }
        }

        #endregion
		#region "P2通风窗手动运行幅度"

        private Byte _P2通风窗手动运行幅度 = default(Byte);

        public Byte P2通风窗手动运行幅度
        {
            get
            {
                return _P2通风窗手动运行幅度;
            }
            set
            {
                if (_P2通风窗手动运行幅度 == value)
                {
                    return;
                }

                _P2通风窗手动运行幅度 = value;
                RaisePropertyChanged("P2通风窗手动运行幅度");
            }
        }

        #endregion
		#region "P2通风窗温室温度有效性"

        private Byte _P2通风窗温室温度有效性 = default(Byte);

        public Byte P2通风窗温室温度有效性
        {
            get
            {
                return _P2通风窗温室温度有效性;
            }
            set
            {
                if (_P2通风窗温室温度有效性 == value)
                {
                    return;
                }

                _P2通风窗温室温度有效性 = value;
                RaisePropertyChanged("P2通风窗温室温度有效性");
            }
        }

        #endregion
		#region "P2通风窗温室温度有效性ACC"

        private Byte _P2通风窗温室温度有效性ACC = default(Byte);

        public Byte P2通风窗温室温度有效性ACC
        {
            get
            {
                return _P2通风窗温室温度有效性ACC;
            }
            set
            {
                if (_P2通风窗温室温度有效性ACC == value)
                {
                    return;
                }

                _P2通风窗温室温度有效性ACC = value;
                RaisePropertyChanged("P2通风窗温室温度有效性ACC");
            }
        }

        #endregion
		#region "P2通风窗温室温度上限"

        private Byte _P2通风窗温室温度上限 = default(Byte);

        public Byte P2通风窗温室温度上限
        {
            get
            {
                return _P2通风窗温室温度上限;
            }
            set
            {
                if (_P2通风窗温室温度上限 == value)
                {
                    return;
                }

                _P2通风窗温室温度上限 = value;
                RaisePropertyChanged("P2通风窗温室温度上限");
            }
        }

        #endregion
		#region "P2通风窗温室温度下限"

        private Byte _P2通风窗温室温度下限 = default(Byte);

        public Byte P2通风窗温室温度下限
        {
            get
            {
                return _P2通风窗温室温度下限;
            }
            set
            {
                if (_P2通风窗温室温度下限 == value)
                {
                    return;
                }

                _P2通风窗温室温度下限 = value;
                RaisePropertyChanged("P2通风窗温室温度下限");
            }
        }

        #endregion
		#region "P2通风窗室外温度下限"

        private Byte _P2通风窗室外温度下限 = default(Byte);

        public Byte P2通风窗室外温度下限
        {
            get
            {
                return _P2通风窗室外温度下限;
            }
            set
            {
                if (_P2通风窗室外温度下限 == value)
                {
                    return;
                }

                _P2通风窗室外温度下限 = value;
                RaisePropertyChanged("P2通风窗室外温度下限");
            }
        }

        #endregion
		#region "P2通风窗确认时间"

        private Byte _P2通风窗确认时间 = default(Byte);

        public Byte P2通风窗确认时间
        {
            get
            {
                return _P2通风窗确认时间;
            }
            set
            {
                if (_P2通风窗确认时间 == value)
                {
                    return;
                }

                _P2通风窗确认时间 = value;
                RaisePropertyChanged("P2通风窗确认时间");
            }
        }

        #endregion
		#region "P2通风窗全程运行时间字符串"

        private String _P2通风窗全程运行时间字符串 = default(String);

        public String P2通风窗全程运行时间字符串
        {
            get
            {
                return _P2通风窗全程运行时间字符串;
            }
            set
            {
                if (_P2通风窗全程运行时间字符串 == value)
                {
                    return;
                }

                _P2通风窗全程运行时间字符串 = value;
                RaisePropertyChanged("P2通风窗全程运行时间字符串");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀手动自动标志"

        private Byte _灌溉加湿电磁阀手动自动标志 = default(Byte);

        public Byte 灌溉加湿电磁阀手动自动标志
        {
            get
            {
                return _灌溉加湿电磁阀手动自动标志;
            }
            set
            {
                if (_灌溉加湿电磁阀手动自动标志 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀手动自动标志 = value;
                RaisePropertyChanged("灌溉加湿电磁阀手动自动标志");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀手动自动标志ACC"

        private Byte _灌溉加湿电磁阀手动自动标志ACC = default(Byte);

        public Byte 灌溉加湿电磁阀手动自动标志ACC
        {
            get
            {
                return _灌溉加湿电磁阀手动自动标志ACC;
            }
            set
            {
                if (_灌溉加湿电磁阀手动自动标志ACC == value)
                {
                    return;
                }

                _灌溉加湿电磁阀手动自动标志ACC = value;
                RaisePropertyChanged("灌溉加湿电磁阀手动自动标志ACC");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀手动运行方向"

        private Byte _灌溉加湿电磁阀手动运行方向 = default(Byte);

        public Byte 灌溉加湿电磁阀手动运行方向
        {
            get
            {
                return _灌溉加湿电磁阀手动运行方向;
            }
            set
            {
                if (_灌溉加湿电磁阀手动运行方向 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀手动运行方向 = value;
                RaisePropertyChanged("灌溉加湿电磁阀手动运行方向");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀手动运行方向ACC"

        private Byte _灌溉加湿电磁阀手动运行方向ACC = default(Byte);

        public Byte 灌溉加湿电磁阀手动运行方向ACC
        {
            get
            {
                return _灌溉加湿电磁阀手动运行方向ACC;
            }
            set
            {
                if (_灌溉加湿电磁阀手动运行方向ACC == value)
                {
                    return;
                }

                _灌溉加湿电磁阀手动运行方向ACC = value;
                RaisePropertyChanged("灌溉加湿电磁阀手动运行方向ACC");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀土壤湿度下限"

        private Byte _灌溉加湿电磁阀土壤湿度下限 = default(Byte);

        public Byte 灌溉加湿电磁阀土壤湿度下限
        {
            get
            {
                return _灌溉加湿电磁阀土壤湿度下限;
            }
            set
            {
                if (_灌溉加湿电磁阀土壤湿度下限 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀土壤湿度下限 = value;
                RaisePropertyChanged("灌溉加湿电磁阀土壤湿度下限");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀土壤湿度上限"

        private Byte _灌溉加湿电磁阀土壤湿度上限 = default(Byte);

        public Byte 灌溉加湿电磁阀土壤湿度上限
        {
            get
            {
                return _灌溉加湿电磁阀土壤湿度上限;
            }
            set
            {
                if (_灌溉加湿电磁阀土壤湿度上限 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀土壤湿度上限 = value;
                RaisePropertyChanged("灌溉加湿电磁阀土壤湿度上限");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀土壤湿度有效性"

        private Byte _灌溉加湿电磁阀土壤湿度有效性 = default(Byte);

        public Byte 灌溉加湿电磁阀土壤湿度有效性
        {
            get
            {
                return _灌溉加湿电磁阀土壤湿度有效性;
            }
            set
            {
                if (_灌溉加湿电磁阀土壤湿度有效性 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀土壤湿度有效性 = value;
                RaisePropertyChanged("灌溉加湿电磁阀土壤湿度有效性");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀土壤湿度有效性ACC"

        private Byte _灌溉加湿电磁阀土壤湿度有效性ACC = default(Byte);

        public Byte 灌溉加湿电磁阀土壤湿度有效性ACC
        {
            get
            {
                return _灌溉加湿电磁阀土壤湿度有效性ACC;
            }
            set
            {
                if (_灌溉加湿电磁阀土壤湿度有效性ACC == value)
                {
                    return;
                }

                _灌溉加湿电磁阀土壤湿度有效性ACC = value;
                RaisePropertyChanged("灌溉加湿电磁阀土壤湿度有效性ACC");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀湿度确认时间"

        private Int16 _灌溉加湿电磁阀湿度确认时间 = default(Int16);

        public Int16 灌溉加湿电磁阀湿度确认时间
        {
            get
            {
                return _灌溉加湿电磁阀湿度确认时间;
            }
            set
            {
                if (_灌溉加湿电磁阀湿度确认时间 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀湿度确认时间 = value;
                RaisePropertyChanged("灌溉加湿电磁阀湿度确认时间");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀固定灌溉有效性"

        private Byte _灌溉加湿电磁阀固定灌溉有效性 = default(Byte);

        public Byte 灌溉加湿电磁阀固定灌溉有效性
        {
            get
            {
                return _灌溉加湿电磁阀固定灌溉有效性;
            }
            set
            {
                if (_灌溉加湿电磁阀固定灌溉有效性 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀固定灌溉有效性 = value;
                RaisePropertyChanged("灌溉加湿电磁阀固定灌溉有效性");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀固定灌溉有效性ACC"

        private Byte _灌溉加湿电磁阀固定灌溉有效性ACC = default(Byte);

        public Byte 灌溉加湿电磁阀固定灌溉有效性ACC
        {
            get
            {
                return _灌溉加湿电磁阀固定灌溉有效性ACC;
            }
            set
            {
                if (_灌溉加湿电磁阀固定灌溉有效性ACC == value)
                {
                    return;
                }

                _灌溉加湿电磁阀固定灌溉有效性ACC = value;
                RaisePropertyChanged("灌溉加湿电磁阀固定灌溉有效性ACC");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀固定灌溉起始时间1小时"

        private Byte _灌溉加湿电磁阀固定灌溉起始时间1小时 = default(Byte);

        public Byte 灌溉加湿电磁阀固定灌溉起始时间1小时
        {
            get
            {
                return _灌溉加湿电磁阀固定灌溉起始时间1小时;
            }
            set
            {
                if (_灌溉加湿电磁阀固定灌溉起始时间1小时 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀固定灌溉起始时间1小时 = value;
                RaisePropertyChanged("灌溉加湿电磁阀固定灌溉起始时间1小时");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀固定灌溉起始时间1分钟"

        private Byte _灌溉加湿电磁阀固定灌溉起始时间1分钟 = default(Byte);

        public Byte 灌溉加湿电磁阀固定灌溉起始时间1分钟
        {
            get
            {
                return _灌溉加湿电磁阀固定灌溉起始时间1分钟;
            }
            set
            {
                if (_灌溉加湿电磁阀固定灌溉起始时间1分钟 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀固定灌溉起始时间1分钟 = value;
                RaisePropertyChanged("灌溉加湿电磁阀固定灌溉起始时间1分钟");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀灌溉时长1分钟"

        private Byte _灌溉加湿电磁阀灌溉时长1分钟 = default(Byte);

        public Byte 灌溉加湿电磁阀灌溉时长1分钟
        {
            get
            {
                return _灌溉加湿电磁阀灌溉时长1分钟;
            }
            set
            {
                if (_灌溉加湿电磁阀灌溉时长1分钟 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀灌溉时长1分钟 = value;
                RaisePropertyChanged("灌溉加湿电磁阀灌溉时长1分钟");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀灌溉时长1小时"

        private Byte _灌溉加湿电磁阀灌溉时长1小时 = default(Byte);

        public Byte 灌溉加湿电磁阀灌溉时长1小时
        {
            get
            {
                return _灌溉加湿电磁阀灌溉时长1小时;
            }
            set
            {
                if (_灌溉加湿电磁阀灌溉时长1小时 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀灌溉时长1小时 = value;
                RaisePropertyChanged("灌溉加湿电磁阀灌溉时长1小时");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀固定灌溉起始时间2小时"

        private Byte _灌溉加湿电磁阀固定灌溉起始时间2小时 = default(Byte);

        public Byte 灌溉加湿电磁阀固定灌溉起始时间2小时
        {
            get
            {
                return _灌溉加湿电磁阀固定灌溉起始时间2小时;
            }
            set
            {
                if (_灌溉加湿电磁阀固定灌溉起始时间2小时 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀固定灌溉起始时间2小时 = value;
                RaisePropertyChanged("灌溉加湿电磁阀固定灌溉起始时间2小时");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀固定灌溉起始时间2分钟"

        private Byte _灌溉加湿电磁阀固定灌溉起始时间2分钟 = default(Byte);

        public Byte 灌溉加湿电磁阀固定灌溉起始时间2分钟
        {
            get
            {
                return _灌溉加湿电磁阀固定灌溉起始时间2分钟;
            }
            set
            {
                if (_灌溉加湿电磁阀固定灌溉起始时间2分钟 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀固定灌溉起始时间2分钟 = value;
                RaisePropertyChanged("灌溉加湿电磁阀固定灌溉起始时间2分钟");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀灌溉时长2分钟"

        private Byte _灌溉加湿电磁阀灌溉时长2分钟 = default(Byte);

        public Byte 灌溉加湿电磁阀灌溉时长2分钟
        {
            get
            {
                return _灌溉加湿电磁阀灌溉时长2分钟;
            }
            set
            {
                if (_灌溉加湿电磁阀灌溉时长2分钟 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀灌溉时长2分钟 = value;
                RaisePropertyChanged("灌溉加湿电磁阀灌溉时长2分钟");
            }
        }

        #endregion
		#region "灌溉加湿电磁阀灌溉时长2小时"

        private Byte _灌溉加湿电磁阀灌溉时长2小时 = default(Byte);

        public Byte 灌溉加湿电磁阀灌溉时长2小时
        {
            get
            {
                return _灌溉加湿电磁阀灌溉时长2小时;
            }
            set
            {
                if (_灌溉加湿电磁阀灌溉时长2小时 == value)
                {
                    return;
                }

                _灌溉加湿电磁阀灌溉时长2小时 = value;
                RaisePropertyChanged("灌溉加湿电磁阀灌溉时长2小时");
            }
        }

        #endregion
		#region "风机手动自动标志"

        private Byte _风机手动自动标志 = default(Byte);

        public Byte 风机手动自动标志
        {
            get
            {
                return _风机手动自动标志;
            }
            set
            {
                if (_风机手动自动标志 == value)
                {
                    return;
                }

                _风机手动自动标志 = value;
                RaisePropertyChanged("风机手动自动标志");
            }
        }

        #endregion
		#region "风机手动自动标志ACC"

        private Byte _风机手动自动标志ACC = default(Byte);

        public Byte 风机手动自动标志ACC
        {
            get
            {
                return _风机手动自动标志ACC;
            }
            set
            {
                if (_风机手动自动标志ACC == value)
                {
                    return;
                }

                _风机手动自动标志ACC = value;
                RaisePropertyChanged("风机手动自动标志ACC");
            }
        }

        #endregion
		#region "风机手动运行方向"

        private Byte _风机手动运行方向 = default(Byte);

        public Byte 风机手动运行方向
        {
            get
            {
                return _风机手动运行方向;
            }
            set
            {
                if (_风机手动运行方向 == value)
                {
                    return;
                }

                _风机手动运行方向 = value;
                RaisePropertyChanged("风机手动运行方向");
            }
        }

        #endregion
		#region "风机手动运行方向ACC"

        private Byte _风机手动运行方向ACC = default(Byte);

        public Byte 风机手动运行方向ACC
        {
            get
            {
                return _风机手动运行方向ACC;
            }
            set
            {
                if (_风机手动运行方向ACC == value)
                {
                    return;
                }

                _风机手动运行方向ACC = value;
                RaisePropertyChanged("风机手动运行方向ACC");
            }
        }

        #endregion
		#region "风机温室温度上限"

        private Byte _风机温室温度上限 = default(Byte);

        public Byte 风机温室温度上限
        {
            get
            {
                return _风机温室温度上限;
            }
            set
            {
                if (_风机温室温度上限 == value)
                {
                    return;
                }

                _风机温室温度上限 = value;
                RaisePropertyChanged("风机温室温度上限");
            }
        }

        #endregion
		#region "风机温室温度下限"

        private Byte _风机温室温度下限 = default(Byte);

        public Byte 风机温室温度下限
        {
            get
            {
                return _风机温室温度下限;
            }
            set
            {
                if (_风机温室温度下限 == value)
                {
                    return;
                }

                _风机温室温度下限 = value;
                RaisePropertyChanged("风机温室温度下限");
            }
        }

        #endregion
		#region "风机温室温度有效性"

        private Byte _风机温室温度有效性 = default(Byte);

        public Byte 风机温室温度有效性
        {
            get
            {
                return _风机温室温度有效性;
            }
            set
            {
                if (_风机温室温度有效性 == value)
                {
                    return;
                }

                _风机温室温度有效性 = value;
                RaisePropertyChanged("风机温室温度有效性");
            }
        }

        #endregion
		#region "风机温室温度有效性ACC"

        private Byte _风机温室温度有效性ACC = default(Byte);

        public Byte 风机温室温度有效性ACC
        {
            get
            {
                return _风机温室温度有效性ACC;
            }
            set
            {
                if (_风机温室温度有效性ACC == value)
                {
                    return;
                }

                _风机温室温度有效性ACC = value;
                RaisePropertyChanged("风机温室温度有效性ACC");
            }
        }

        #endregion
		#region "风机室外温度下限低字节用于不开风扇"

        private Byte _风机室外温度下限低字节用于不开风扇 = default(Byte);

        public Byte 风机室外温度下限低字节用于不开风扇
        {
            get
            {
                return _风机室外温度下限低字节用于不开风扇;
            }
            set
            {
                if (_风机室外温度下限低字节用于不开风扇 == value)
                {
                    return;
                }

                _风机室外温度下限低字节用于不开风扇 = value;
                RaisePropertyChanged("风机室外温度下限低字节用于不开风扇");
            }
        }

        #endregion
		#region "风机温度确认时间"

        private Byte _风机温度确认时间 = default(Byte);

        public Byte 风机温度确认时间
        {
            get
            {
                return _风机温度确认时间;
            }
            set
            {
                if (_风机温度确认时间 == value)
                {
                    return;
                }

                _风机温度确认时间 = value;
                RaisePropertyChanged("风机温度确认时间");
            }
        }

        #endregion
		#region "湿帘泵手动自动标志"

        private Byte _湿帘泵手动自动标志 = default(Byte);

        public Byte 湿帘泵手动自动标志
        {
            get
            {
                return _湿帘泵手动自动标志;
            }
            set
            {
                if (_湿帘泵手动自动标志 == value)
                {
                    return;
                }

                _湿帘泵手动自动标志 = value;
                RaisePropertyChanged("湿帘泵手动自动标志");
            }
        }

        #endregion
		#region "湿帘泵手动自动标志ACC"

        private Byte _湿帘泵手动自动标志ACC = default(Byte);

        public Byte 湿帘泵手动自动标志ACC
        {
            get
            {
                return _湿帘泵手动自动标志ACC;
            }
            set
            {
                if (_湿帘泵手动自动标志ACC == value)
                {
                    return;
                }

                _湿帘泵手动自动标志ACC = value;
                RaisePropertyChanged("湿帘泵手动自动标志ACC");
            }
        }

        #endregion
		#region "湿帘泵手动运行方向"

        private Byte _湿帘泵手动运行方向 = default(Byte);

        public Byte 湿帘泵手动运行方向
        {
            get
            {
                return _湿帘泵手动运行方向;
            }
            set
            {
                if (_湿帘泵手动运行方向 == value)
                {
                    return;
                }

                _湿帘泵手动运行方向 = value;
                RaisePropertyChanged("湿帘泵手动运行方向");
            }
        }

        #endregion
		#region "湿帘泵手动运行方向ACC"

        private Byte _湿帘泵手动运行方向ACC = default(Byte);

        public Byte 湿帘泵手动运行方向ACC
        {
            get
            {
                return _湿帘泵手动运行方向ACC;
            }
            set
            {
                if (_湿帘泵手动运行方向ACC == value)
                {
                    return;
                }

                _湿帘泵手动运行方向ACC = value;
                RaisePropertyChanged("湿帘泵手动运行方向ACC");
            }
        }

        #endregion
		#region "湿帘泵温室温度上限"

        private Byte _湿帘泵温室温度上限 = default(Byte);

        public Byte 湿帘泵温室温度上限
        {
            get
            {
                return _湿帘泵温室温度上限;
            }
            set
            {
                if (_湿帘泵温室温度上限 == value)
                {
                    return;
                }

                _湿帘泵温室温度上限 = value;
                RaisePropertyChanged("湿帘泵温室温度上限");
            }
        }

        #endregion
		#region "湿帘泵温室温度下限"

        private Byte _湿帘泵温室温度下限 = default(Byte);

        public Byte 湿帘泵温室温度下限
        {
            get
            {
                return _湿帘泵温室温度下限;
            }
            set
            {
                if (_湿帘泵温室温度下限 == value)
                {
                    return;
                }

                _湿帘泵温室温度下限 = value;
                RaisePropertyChanged("湿帘泵温室温度下限");
            }
        }

        #endregion
		#region "湿帘泵温室温度有效性"

        private Byte _湿帘泵温室温度有效性 = default(Byte);

        public Byte 湿帘泵温室温度有效性
        {
            get
            {
                return _湿帘泵温室温度有效性;
            }
            set
            {
                if (_湿帘泵温室温度有效性 == value)
                {
                    return;
                }

                _湿帘泵温室温度有效性 = value;
                RaisePropertyChanged("湿帘泵温室温度有效性");
            }
        }

        #endregion
		#region "湿帘泵温室温度有效性ACC"

        private Byte _湿帘泵温室温度有效性ACC = default(Byte);

        public Byte 湿帘泵温室温度有效性ACC
        {
            get
            {
                return _湿帘泵温室温度有效性ACC;
            }
            set
            {
                if (_湿帘泵温室温度有效性ACC == value)
                {
                    return;
                }

                _湿帘泵温室温度有效性ACC = value;
                RaisePropertyChanged("湿帘泵温室温度有效性ACC");
            }
        }

        #endregion
		#region "湿帘泵室外温度下限低字节用于不开泵"

        private Byte _湿帘泵室外温度下限低字节用于不开泵 = default(Byte);

        public Byte 湿帘泵室外温度下限低字节用于不开泵
        {
            get
            {
                return _湿帘泵室外温度下限低字节用于不开泵;
            }
            set
            {
                if (_湿帘泵室外温度下限低字节用于不开泵 == value)
                {
                    return;
                }

                _湿帘泵室外温度下限低字节用于不开泵 = value;
                RaisePropertyChanged("湿帘泵室外温度下限低字节用于不开泵");
            }
        }

        #endregion
		#region "湿帘泵温度确认时间"

        private Byte _湿帘泵温度确认时间 = default(Byte);

        public Byte 湿帘泵温度确认时间
        {
            get
            {
                return _湿帘泵温度确认时间;
            }
            set
            {
                if (_湿帘泵温度确认时间 == value)
                {
                    return;
                }

                _湿帘泵温度确认时间 = value;
                RaisePropertyChanged("湿帘泵温度确认时间");
            }
        }

        #endregion
		#region "温室温度报警上限"

        private Byte _温室温度报警上限 = default(Byte);

        public Byte 温室温度报警上限
        {
            get
            {
                return _温室温度报警上限;
            }
            set
            {
                if (_温室温度报警上限 == value)
                {
                    return;
                }

                _温室温度报警上限 = value;
                RaisePropertyChanged("温室温度报警上限");
            }
        }

        #endregion
		#region "温室温度报警下限"

        private Byte _温室温度报警下限 = default(Byte);

        public Byte 温室温度报警下限
        {
            get
            {
                return _温室温度报警下限;
            }
            set
            {
                if (_温室温度报警下限 == value)
                {
                    return;
                }

                _温室温度报警下限 = value;
                RaisePropertyChanged("温室温度报警下限");
            }
        }

        #endregion
		#region "土壤湿度报警上限"

        private Byte _土壤湿度报警上限 = default(Byte);

        public Byte 土壤湿度报警上限
        {
            get
            {
                return _土壤湿度报警上限;
            }
            set
            {
                if (_土壤湿度报警上限 == value)
                {
                    return;
                }

                _土壤湿度报警上限 = value;
                RaisePropertyChanged("土壤湿度报警上限");
            }
        }

        #endregion
		#region "土壤湿度报警下限"

        private Byte _土壤湿度报警下限 = default(Byte);

        public Byte 土壤湿度报警下限
        {
            get
            {
                return _土壤湿度报警下限;
            }
            set
            {
                if (_土壤湿度报警下限 == value)
                {
                    return;
                }

                _土壤湿度报警下限 = value;
                RaisePropertyChanged("土壤湿度报警下限");
            }
        }

        #endregion
		#region "报警确认时间"

        private Byte _报警确认时间 = default(Byte);

        public Byte 报警确认时间
        {
            get
            {
                return _报警确认时间;
            }
            set
            {
                if (_报警确认时间 == value)
                {
                    return;
                }

                _报警确认时间 = value;
                RaisePropertyChanged("报警确认时间");
            }
        }

        #endregion
	}
}
